import base64
import os
import time
from dashscope import MultiModalConversation
from openai import OpenAI
from pathlib import Path

# 设置阿里云百炼 API Key
os.environ["DASHSCOPE_API_KEY"] = "sk-5c6689dccd074a739c78ef7d1d780148"


def ask_llm(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            # 请求 Chat Completion
            completion = client.chat.completions.create(
                model="deepseek-v3.1",
                messages=[
                    {"role": "system", "content": '''
                    
                    首先你需要根据语义理解和判断，user输入的content中是否包含在下面'{}'中，有以下几个点：1是否是一模一样的内容，2如果不是一模一样的内容，你需要根据语义理解去判断是否是一样的问题，语义理解查看是否有同义或者近义，或者相似的,理解完成后再进行判断，如果没有类似的问题，则不要硬套和匹配。      
                    
                    
                    1：{例子1:‘代收通道是否正常’，例子2:'代收正常吗',根据前面的几个例子进行语义理解，然后给出正确的判断，与前面例子无关的信息则返回无即可}，如果有，则返回'1',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    2：{例子1:‘代付通道是否正常，代付速度怎么样’，例子2:'代付出的快吗？',例子3:'提交代付一般多久到账？',例子4:'代付顺畅吗？',例子5:'代付通道现在稳定吗？',例子6:'代付成功率高吗？',例子7:'银行卡代付吗？',例子8:'代付正常吗',例子9:'代付通道是否正常',例子10:'代付能用吗'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'2',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    3：{例子1:‘代付加急’，例子2:'代付卡单原因',例子3:'这笔卡这么久什么原因导致？',例子4:'代付卡单情况',例子5:'xxxxxx订单 帮看下订单状态',例子6:'xxxxx订单现在什么状态',例子7:'xxxxxxx 麻烦帮忙卡在已提交中的尽快回调一下哈',其中像'xxxxx'代表订单号，你需要根据前面已经给的几个例子，进行语义理解，然后给出相应的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'3',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    4：{例子1:‘xxxx（商户号） 麻烦付款凭证提供下「关键字“凭证”」’,这里的关键词是'凭证'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'4',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    5：{例子1:'看该utr是否被使用',根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'5',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    6：{例子1:'代付订单xxx失败原因','xxxxxx（商户单号） 麻烦查下这笔订单失败原因？',「关键字“代付失败原因”」,你需要在这里自行判断是否有代付失败的原因这个意思，根据前面的几个例子进行语义理解，然后给出正确的判断,,与前面例子无关的信息则返回无即可}，如果有，则返回'6',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    7：{例子1:'支持的通道类型',例子2:'代收/代付支持哪些channel',例子3:'代收/代付支持哪些渠道',根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'7',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    8：{例子1:'代收成功率怎么样',例子2:'通道稳吗？',例子3:'代收跑得动吗？',例子4:'现在整体成功率多少？',例子5:'会员付款失败了，通道正常吗？',例子6:'刚才提的几笔都失败了，目前通道正常吗？'，这里主要是识别到”成功率“即可恢复，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'8',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    9：{例子1:'代付冲正xxx',例子2: '单号：xxx,用户表示没收到款，麻烦查下什么情况',例子3:'251024YWD4CEB60065871319 冲正了吗',关键词"xxx 冲正",xxx代表订单号，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'9',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    10：{例子1:'查询余额',根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'10',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    11：{例子1:'查询下发汇率',根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'11',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    12：{例子1:'订单xxx是否提交到我们后台',根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'12',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    13：{例子1:'如何使用公钥，密钥',根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'13',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    14：{例子1:’测试环境和正式环境的回调ip是否一致‘，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'14',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    15：{例子1:’测试环境，正式环境回调‘，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'15',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    16：{例子1:’代收入账‘，例子2:'余额增加(手动)',例子3:'余额减少(手动)',例子4:'提现/转账/结算',例子5:'待结算',例子6:'代收结算',例子7:'委托结算',例子8:'提款驳回',例子9:'代付驳回',例子10:'转账扣除',例子11:'转账到账',例子12:'冻结',例子13:'解冻',例子14:'代收退款',例子15:'代付退款',例子16:'提款退款',例子17:'代付冻结',例子18:'代付解除冻结',例子19:'提现冻结',例子20:'提现解除冻结',例子21:'代付冻结结算',例子22:'提现冻结结算',根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，
                        如果有，则返回'16',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    17：{例子1:'xxx 代付驳回',例子2:'代付卡单 xxx 驳回',例子3:'麻烦驳回这笔单子xxx',关键词是驳回，xxx代表订单号，如果这里没有识别到订单号则判断为无，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'17',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    18：{例子1:'代收怎么掉单这么严重？','“掉单”是触发词'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'18',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    19：{例子1:'VA返回的付款碼，您那邊一般是怎麼呈現？'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'19',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    20：{例子1:'代付钱包账号和手机号是一样的吗？'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'20',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    21：{例子1:'需要内充及更换提U地址'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'21',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    22：{例子1:'新商户登录后台，没有弹出谷歌二维码绑定，如何解决？'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'22',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    23：{例子1:'有办法模拟代付吗？'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'23',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    24：{例子1:'商户密钥是一定需要重置的是吗？'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'24',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    25：{例子1:'测试环境代收回调问题?'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'25',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    26：{例子1:'印尼指令'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'26',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    27：{例子1:'印度指令'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'27',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    28：{例子1:'孟加拉指令'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'28',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    29：{例子1:'巴基斯坦指令'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'29',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    30：{例子1:'251027YW9B167E0096420239 流水号提供下',例子2:'251027YW9B167E0096420239 utr提供下'，例子3:'xxxx 流水号提供下',关键词'utr提供下'，或者流水号提供下，这里需要你判断一下，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'30',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    31：{例子1:'d2072510270356586160399 这笔代付成功了吗'，根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'31',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    32：{例子1:'481094464396这个utr对应单号是'，例子2:'rafee72596385@barodampay 是你们的upi 账户吗'，例子3:'ppqr01.syhdxh@iob  是你们的户吗'，例子4:'MAHATHIGROUPS@rbl 是你们的吗'，例子5:'indra5158@fbl 是你们的吗'，例子5:'brotherscarhub.90474301@sbi 是你们的吗'，例子6:'JKBMERC00456748@jkb 是你们的吗',前面是给的几个有关upi的例子，关键词"utr，upi",如果没有这些关键词，那你就需要根据给的这几个例子，对所给的问题进行语义理解，然后给出你的答案。根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'32',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    33：{例子1:'s082510250952358558062 帮查下，这笔有没有收到钱的',像这样的给个订单号xxx，然后后面给一些指令，关键词'xxx 是否收到钱'，xxx代指订单号，你需要进行意图识别，语义理解，然后给出你的判断。根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'33',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    34：{例子1:'大盘成功率',关键词是’大盘‘，这里主要识别”大盘“，“成功率”很微弱你需要进行意图识别，语义理解，然后给出你的判断。根据前面的几个例子进行语义理解，然后给出正确的判断,与前面例子无关的信息则返回无即可}，如果有，则返回'34',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    
                    
                    
                    
                    
                    
                    最终返回的答案为上面的纯数字，如果根据上面的内容匹配不到，或者完全没有找到相似的内容，则返回'无'。
    
                    禁止回答其他有的内容。
                    
                    '''},
                    {"role": "user", "content": prompt},
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            print("LLM Error:", e)
            time.sleep(2)
    raise Exception("多次重试仍然失败")

def ask_llm_qwen3(question):
    # 连接本地 vLLM 服务
    client = OpenAI(
        base_url="http://47.236.192.56:8000/v1",
        api_key="EMPTY"  # vLLM 不验证 key，可以随便填
    )

    # 调用对话接口
    response = client.chat.completions.create(
        model="/root/autodl-tmp/data/merge_model/m_models",  # 或者你的模型名/路径
        messages=[
            {"role": "system", "content": "你是一个智能客服助手，名字叫远贝。你需要根据问题，识别问题，回答相关的问题"},
            {"role": "user", "content": question}
        ],
        temperature=0.7,
        max_tokens=512
    )
    # print("模型回复：", response.choices[0].message.content)
    return response.choices[0].message.content

def ask_llm_upstream(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system", "content": '''
                
                    你需要根据user输入的content，查找content中是否有下面列表中所包含的关键词，你是一个语义理解的小助手，适当的时候需要语义理解词语意思.
                    
                    1.{'账户信息错误','网络异常','网络波动导致的失败'},如果有，则返回'1',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    2.{'utr/付款凭证图片'},如果有，则返回'2',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。
                    
                    禁止返回其他的内容，禁止输入其他的信息

                '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm_upstream_payout(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system", "content": '''

                    你需要根据user输入的content，查找content中是否有下面列表中所包含的关键词，你是一个语义理解的小助手，适当的时候需要语义理解词语意。

                    
                    1.{'代付订单xxx失败原因','xxxxxx（商户单号） 麻烦查下这笔订单失败原因？「关键字“失败原因”」','xxxxxxx（商户号） 麻烦付款凭证提供下「关键字“付款凭证”},如果有，则返回'1',只返回纯数字，不返回其他的任何内容，禁止返回无关内容。


                    禁止返回其他的内容，禁止输入其他的信息

                '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"

def ask_llm_re_country_name(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            completion = client.chat.completions.create(
                model="deepseek-v3.1",
                messages=[
                    {"role": "system", "content":
                        '''

                        你需要根据user输入的content提取出编号，

                        如'28198-印度&Deepay',提取出来的编号是'28198'，像这样的开头是5个连续的纯数字组成，就需要提取出来编号，就是成功的；

                        如'216-5-AXPAY-7.5+3+6 四方 原208'，像这样的开头没有连续的5个纯数字组成，那就无法提取出来编号，就不提取，返回'无'；
                        
                        首先你需要在这里判断清楚编号的第一个数字是什么，然后去执行下面的任务，第一个数字至关重要，影响到最后的结果，必须要看清楚，


                        1.编号由5个数字组成，如果编号的第一个数字是1，则对应的国家是印度，则对应的地址是"https://adm.deepay.ink"

                        2.编号由5个数字组成，如果编号的第一个数字是2，则对应的国家是印尼，则对应的地址是"https://adm.deepaym.com"

                        3.编号由5个数字组成，如果编号的第一个数字是3，则对应的国家是巴基斯坦，则对应的地址是"https://admpkr.deepay.ink"

                        4.编号由5个数字组成，如果编号的第一个数字是4，则对应的国家是巴西，则对应的地址是"https://admbr.deepay.ink"

                        5.编号由5个数字组成，如果编号的第一个数字是5，则对应的国家是孟加拉，则对应的地址是"https://admbd.deepay.ink"
                        
                        上述国家名称和地址需要严格执行，不允许出错，编号的第一个数字必须判断清楚。

                        然后，你需要将国家对应的地址和对应的编号以及对应的国家名称，填写到下面的字典里面,地址对应的是"address"，编号对应的是"mid"

                        给你一个列子，如果是印尼，则返回：

                        {"address":"https://adm.deepaym.com","mid":"28204"}

                        你就按照上面的这种填写就行，然后返回给我即可，

                        如果有数据,则返回像这样的:{"address":"https://adm.deepaym.com","mid":"28204"}

                        如果找不到编号，则返回"无"，纯文字，禁止返回其他的内容,
                        
                        一定不要返回空字符串，不要返回给我其他任意的无用的内容，

                        其他的不需要返回,禁止回答其他的内容。

                        '''},
                    {"role": "user", "content": prompt},
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            print("LLM Error:", e)
            return "抱歉，AI 处理时出现错误。"
            time.sleep(2)
    raise Exception("多次重试仍然失败")


def ask_llm_result(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            # 请求 Chat Completion
            completion = client.chat.completions.create(
                model="deepseek-v3",
                messages=[
                    {"role": "system", "content":
                        '''
                        
                        你需要根据user输入的content中,查找是否包含'流水与订单时间相符合'的文字,这里面主要关注'相符合'还是'不相符合',如果是'相符合',则返回y,如果是'不相符合',则返回n.
                        
                        如果包含,那你返回给我y,单纯字母,禁止返回其他的内容,
                        
                        如果没有包含,那你返回n,单纯字母,禁止返回其他的内容,
                        
                        最后返回的内容,不是y,就是n,禁止返回其他的内容,
                        
                        其他的不需要返回,禁止回答其他的内容。

                        '''},
                    {"role": "user", "content": prompt},
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            print("LLM Error:", e)
            return "抱歉，AI 处理时出现错误。"
            time.sleep(2)
    raise Exception("多次重试仍然失败")


def ask_llm_common(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            # 请求 Chat Completion
            completion = client.chat.completions.create(
                model="deepseek-v3",
                messages=[
                    {"role": "system",
                     "content": "你只需总结user輸入的content的内容，变换一下content的内容即可，但是意思一样，你只管总结輸入的文本内容，其他的不要深入解析，开头需要礼貌一点，像一个人一样去回答，禁止回答无关紧要的语句。"},
                    {"role": "user", "content": prompt},
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            print("LLM Error:", e)
            return "抱歉，AI 处理时出现错误。"
            time.sleep(2)
    raise Exception("多次重试仍然失败")


def ask_llm_re_password(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            # 请求 Chat Completion
            completion = client.chat.completions.create(
                model="deepseek-v3",
                messages=[
                    {"role": "system",
                     "content": '''
                     
                     你需要提取出user输入的content中的密码：
                     
                     一般是一个文件名称，密码在'pass:'和'.pdf'的中间，密码通常由数字和字母组成，
                     
                     如"印度-查询中- SURA0805-pass：SURA0805-.pdf",提取出来的密码为'SURA0805',
                     
                     只提取密码，如果没有密码，则返回'空'即可，只。
                     
                     
                     有密码则返回密码，没有密码则返回'空'字，纯文字，
                     
                     其余内容不要返回，
                     
                     禁止回答无关紧要的语句。
                     
                     '''},
                    {"role": "user", "content": prompt},
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            print("LLM Error:", e)
            return "抱歉，AI 处理时出现错误。"
            time.sleep(2)
    raise Exception("多次重试仍然失败")


def ask_llm_re_passw(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            # 请求 Chat Completion
            completion = client.chat.completions.create(
                model="deepseek-v3",
                messages=[
                    {"role": "system",
                     "content": '''
    
                     你需要提取出user输入的content中的密码：
                     
                     输入的content中，密码名称可能是：'PW',也可能是'pwss','password',有这些密码的字词，那就可以提取后面的密码了，你需要自己进行判断，然后提取出来密码。
    
                     如'PW:51788180',提取出来的密码为51788180，返回密码即可,密码都是由数字和字母组成的，
    
                     提取密码的过程中，你需要自己判断哪个是密码，可以按照给的案列判断密码，然后提取密码，然后只返回密码即可。
                     
                     如果没有密码，则返回"空"，
    
                     其余内容不要返回，
                     
                     禁止返回空字符串，
                     
    
                     禁止回答无关紧要的语句。
    
                     '''},
                    {"role": "user", "content": prompt}
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            print("LLM Error:", e)
            return "抱歉，AI 处理时出现错误。"
            time.sleep(2)
    raise Exception("多次重试仍然失败")


def ask_llm1_2():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''
                    
                    '老板，代收正常的'
                    
                    
                    根据上面这句话回答，简介，简单，像人一样回复,回复语句前面需要加上'代收'。
                    
                    
                    给你举个例子：'代收正常的呢',
                    
                    只输出纯文字，不要出现'',
                    
                    可以按照这种风格回复
                 
                 
                 '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm1_3():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    '这会通道有些波动，我们优化下哦'

                    根据上面这句话回答，简介，简单，像人一样回复,回复语句前面需要加上'代收'。
                    
                    给你举个列子：'代收有些波动，我们优化下哦'
                    
                    回复的过程中，不要出现'代收好的'，这种不好的词语，尽可能像例子中的一样就行，
                    
                    只输出纯文字，不要出现'',
                    
                    
                    可按照这种风格回复。


                 '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm1_4():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    '维护中，恢复通知哦'
                    
                    按照上面的这种回复风格回复,
                    
                    回复像人一样，

                    只输出纯文字，不要出现'',


                    可按照这种风格回复。


                 '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm1_1():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''
                 
                 '抱歉老板，这会通道在波动，我们正加急排查中/老板，这会代收维护中。'
                 
                 变换一下这句话，意思不要变，尽可能简介，简单，稍加生动，拟人化，像人一样回答,回复语句前面需要加上'代收'。
                 
                 给你举个回复的例子：'代收在波动，我们正加急排查中or代收/通道-维护中'
                 
                 只输出纯文字，不要出现'',
                 
                 
                 可以按照这种风格回复。
                 
                 '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": "变换一下文字内容，意思不变，简洁，禁止回答无关紧要的语句。。"},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm3(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": "变换一下文字内容，意思不变，简洁，禁止回答无关紧要的语句。。"},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm_minute(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''
                    
                    你需要根据user輸入的content，提取出'minute',如：'查询近五分钟的成功率',提取出来'五分钟'，然后将'五分钟'变成'5'即可，
                    
                    其他的时间minute也一样，最后只返回数字即可，如果没有时间，则返回空，禁止返回其他的内容。
                    
                    
                    '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm1_0(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system", "content": '''
                
                你需要查找user輸入的content，识别content里面是否有’代收通道是否正常‘,'代收正常吗'，或者语义相近的意思，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                
                '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content":
                     '''你需要根据变换一下content，但是意思一样。
                     
                     有以下几个点需要注意：
                     
                     不要出现"更优惠"这些词
                 
                                
                    然后返回，禁止回答无关紧要的语句。'''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2_1():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content":
                     '''
                     
                     '代付速度快，秒（现在秒出，可多多提单哟～）'
                 
                     变换一下这句话，意思不要变，尽可能简介，简单，稍加生动，拟人化，像人一样回答,回复语句前面需要加上'代付'。
                     
                    
                     
                     只输出纯文字，不要出现''，
                     
                     禁止自由发挥。
                     
                    
                    '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2_2():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content":
                     '''

                     '代付速度正常（现在速度还可以，欢迎提单哦～）'

                     变换一下这句话，意思不要变，尽可能简介，简单，稍加生动，拟人化，像人一样回答,回复语句前面需要加上'代付'。



                     只输出纯文字，不要出现''，

                     禁止自由发挥。


                    '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2_3():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content":
                     '''

                     '代付有延迟，正在加急处理，（这会出款速度不快，急单勿提）'

                     变换一下这句话，意思不要变，尽可能简介，简单，稍加生动，拟人化，像人一样回答,回复语句前面需要加上'代付'。



                     只输出纯文字，不要出现''，

                     禁止自由发挥。


                    '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2_4():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content":
                     '''

                     '代付速度慢，急单勿提（这会回调速度慢，急单勿提）'

                     变换一下这句话，意思不要变，尽可能简介，简单，稍加生动，拟人化，像人一样回答,回复语句前面需要加上'代付'。



                     只输出纯文字，不要出现''，

                     禁止自由发挥。


                    '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2_5():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content":
                     '''

                     '维护中，恢复通知噢'

                     变换一下这句话，意思不要变，尽可能简介，简单，稍加生动，拟人化，像人一样回答。



                     只输出纯文字，不要出现''，

                     禁止自由发挥。


                    '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2_6(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content":
                     '''

                     根据user输入的content，判断是不是json格式，
                     
                     如果是json格式，则返回'y',如果不是,则返回'n',
                     
                     禁止返回其他的内容，只需要按照要求来回答就行。


                    '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm2_0(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''
                 
                    你需要查找user輸入的content，识别content里面是否有
                    
                    ’代付通道是否正常，代付速度怎么样'，
                    '代付出的快吗？',
                    '提交代付一般多久到账？',
                    '代付顺畅吗？',
                    '代付通道现在稳定吗？',
                    '代付成功率高吗？',
                    '银行卡代付吗？',
                    ''
                    
                    或者语义相近的意思，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                 
                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm3(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": "你只需总结user輸入的文本内容，变换一下輸入内容，但是意思一样，开头需要礼貌一点。禁止回答无关紧要的语句。"},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"

def ask_llm3_0(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''
                 
                    你需要查找user輸入的content，识别content里面是否有’代付加急'，或者语义相近的意思，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                 
                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm4(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''
                 
                 你需要查找user輸入的content，识别content里面是否有’代付订单失败原因‘，或者语义相近的意思，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。
                 
                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm4_0(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，识别content里面是否有’代付卡单原因‘，或者语义相近的意思，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm5(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": "你只需总结user輸入的文本内容，变换一下輸入内容，但是意思一样，开头需要礼貌一点。禁止回答无关紧要的语句。"},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm6(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，识别content里面是否有’utr的账号是332546375258是否被使用‘，或者语义相近的意思，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm7(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要根据user輸入的content，将里面的utr的账号提取出来，只提取数字账号，只返回账号，其他的都不返回，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        print("ok1", completion.choices[0].message.content)
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm8(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要根据user輸入的content，你需要根据语义来判断里面的订单号，然后将里面的’代付订单TR2407244bwezxmbsWafOA32fW失败原因‘或者是
                 ’代付订单order_1721801593失败原因‘的订单号提取出来，只提取订单号，只返回订单号，
                 其他的都不返回，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm9():
    client = OpenAI(
        api_key="sk-zABGgyHj3rb59p5zzyxkUwLMwUeULUbfTuj7i5Zze8ha5vFS",
        base_url="https://api.moonshot.cn/v1",
    )

    # xlnet.pdf 是一个示例文件, 我们支持 pdf, doc 以及图片等格式, 对于图片和 pdf 文件，提供 ocr 相关能力
    file_object = client.files.create(file=Path("D:\\yuanbei\\data\\test.pdf"), purpose="file-extract")

    # 获取结果
    # file_content = client.files.retrieve_content(file_id=file_object.id)
    # 注意，之前 retrieve_content api 在最新版本标记了 warning, 可以用下面这行代替
    # 如果是旧版本，可以用 retrieve_content
    file_content = client.files.content(file_id=file_object.id).text

    # 把它放进请求中
    messages = [
        {
            "role": "system",
            "content": '''

                    你是我的小助手，你需要根据輸入的pdf，从里面找出对应的内容，最后用json输出，
                    第一个字段：”Account Number“，以及对呀的值
                    第二个字段：”Description“和’Credit‘，这个需要在表格中找，条件是查找’Description‘等于’518905250794‘的值，以及对应的Credit的值，

                    输出格式：
                    {
                      "Account Number": "00000020169623037",
                      "Description": "518905250794",
                      "Credit": "1,061.00"
                    }
                    即可


                    禁止输出其他的内容。


                    ''',
        },
        {
            "role": "system",
            "content": file_content,
        }
    ]

    # 然后调用 chat-completion, 获取 Kimi 的回答
    completion = client.chat.completions.create(
        model="kimi-k2-0711-preview",
        messages=messages,
        temperature=0.6,
    )

    # print(completion.choices[0].message.content)

    return completion.choices[0].message.content


def ask_llm10(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，识别content里面是否有’支持的通道类型‘，'代收/代付支持哪些channel','代收/代付支持哪些渠道',或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。
                 

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm11(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，你将会得到json格式的数据，json里面主要表现的是通道的数据，有三种类型，分别是payCode、name、type，
                 首先你需要根据type判断有几个大类，然后每个大类后面跟着type对应的payCode，
                 
                 回答格式如下：
                 '
                 你好，我们代收目前支持以下通道：
                 
                 BANK VA：MANDIRI、PERMATA
                 QRIS：QRIS
                 WALLET：OVO
                 '
                 
                 然后输出即可,最后输出只需要输出纯文字，其余的不要输出，如'',
                 
                 禁止回答其他得内容。
                 

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm12(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，识别content里面是否有’如何使用公钥，密钥‘，或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm13(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要根据user輸入的content，判断content里面包含的是’公钥’还是 ‘密钥‘，如果是’公钥‘，那你返回’y‘即可，如果是’密钥‘，则返回’n‘，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm14(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，识别content里面是否有’测试环境和正式环境的回调ip是否一致‘，或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm15(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，识别content里面是否有’测试环境，正式环境回调‘，或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm16(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，识别content里面是否有’测试环境回调’和‘正式环境回调‘，或者语义相近的意思，同义词，近义词都行，如果是’测试环境回调‘，那你返回’y‘即可，如果是’正式环境回调‘，那你就返回’n‘，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm17(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要根据user輸入的content，变换一下内容，意思不变，开头需要礼貌一些，总字数不超20字，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm18(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，识别content里面是否有
                 ’代收入账‘，
                ’余额增加(手动)‘，
                ’余额减少(手动)’，
                ‘提现/转账/结算’，
                ‘待结算’，
                ‘代收结算’，
                ‘委托结算’，
                ‘提款驳回’，
                ‘代付驳回’，
                ‘转账扣除’，
                ‘转账到账’，
                ‘冻结’，
                ‘解冻’，
                ‘代收退款’，
                ‘代付退款’，
                ’提款退款‘，
                ’代付冻结‘，
                ’代付解除冻结‘，
                ’提现冻结‘，
                ’提现解除冻结‘，
                ’代付冻结结算‘，
                ’提现冻结结算‘
                 或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有则返回’n‘，禁止返回其他的内容，严格执行命令。

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm19(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                 你需要查找user輸入的content，根据輸入的问题，到下面的列表查找相对应的答案，
                 {
                    '代收入账':'代收成功时入账。可用余额增加',
                    '余额增加(手动)':'管理员手动操作。增加可用余额',
                    '余额减少(手动)':'管理员手动操作。减少可用余额',
                    '提现/转账/结算':'已作废弃用',
                    '待结算':'非实时结算的代收订单支付成功，增加带待结算余额',
                    '代收结算:'非实时结算的代收订单结算时，减少带待结算余额，增加可用余额',
                    '委托结算':'已作废弃用',
                    '提款驳回':'已作废弃用',
                    '代付驳回':'已作废弃用',
                    '转账扣除':'商户互转，转出，可用余额减少',
                    '转账到账':'商户互转，转人，可用余额增加',
                    '冻结':'代收订单金额冻结，冻结金额增加，可用余额减少',
                    '解冻':'代收订单金额解冻，冻结金额减少，可用余额增加',
                    '代收退款':'代收订单退款（投诉）,可用余额减少',
                    '代付退款':'代付订单退款（冲正）,可用余额增加',
                    '提款退款':'提现订单退款（冲正）,可用余额增加',
                    '代付冻结':'代付订单申请成功，可用余额减少，冻结金额增加',
                    '代付解除冻结':'代付订单出款失败，可用余额增加，冻结金额减少',
                    '提现冻结':'提现订单申请成功，可用余额减少，冻结金额增加',
                    '提现解除冻结':'提现订单出款失败，可用余额增加，冻结金额减少',
                    '代付冻结结算‘':' 代付订单出款成功，冻结金额减少',
                    '提现冻结结算':'提现订单出款成功，冻结金额减少'
                }
                
                找到对应问题的答案后，首先开头回答需要用礼貌的语气，然后将答案做一个简单的总结即可，不需要你自由发挥。
                
                禁止回答其他不相关的内容。


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm20(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，识别content里面是否有'请根据订单号xxxxx，查一下代付冲正'，或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有，那你就返回’n‘，禁止返回其他的内容，严格执行命令。


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm20_1(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            # 请求 Chat Completion
            completion = client.chat.completions.create(
                model="deepseek-v3",
                messages=[
                    {"role": "system",
                     "content": '''
    
                        你需要查找user輸入的content，请根据輸入的content，提取出订单号，
                        
                        通常是有订单号的，你需要仔细检查，提取到订单号，如一般由连在一起的字母和数字组合在一起的，一般很长，会有20个连续以上的数字和字母组成，所以你找起来很方便的。
                        
                        一般传进来的content中包含订单号，提取的过程中，订单号要完整，齐全，不要丢掉一个字母一个数字，
                        
                        订单号由不同的字母和数字组成，一整串，提取的过程中，需要完整提取出来，
                        
                        
                        第一种情况，订单号只有一个，最后按照我给你的json格式的列子返回订单号即可：
                        
                            例子1：
                            ‘d1082507312356558215177
                            5217821
                            YD8-Deepay
                            2025-07-31 23:56:55’
                            
                            那么你提取出来的内容为： d1082507312356558215177,
                            
                            返回格式为json格式：
                            
                            
                            {
                                'order_ids':[
                                    'd1082507312356558215177',
                                    ]
                            }
                            
                            严禁输出```json```
                        
                        第二种情况，订单号有多个，最后要把所有的订单号都返回，
                        
                            例子2：
                            
                            '
                            TR250831CUzaOLL8N02ePV7ORe
                            TR250831sxxHjEXCeWlH0QMdA5
                            TR250831IYnkX3fr1F6YmnaC1E
                            TR250831D2g97QtwiuVa5bCNrw
                            TR250831FYKKBd07R4JeTc2Iae
                            TR250831BF8VfXLZLWXsB5YzQc
                            TR250831gQW6MdyEky5xjeRExa
                            TR2508314nKc3tg28rs2Pl6HpS
                            TR250831oLK3FxDrGEEDXEqnaS
                            TR250831bRnUop0RDSqZDbYKfX
                            TR250831XkApJaGy3BNouNLIZb
                            TR250831JY0r7ZMBypNzYnNIsK
                            TR250831VOLY7NlbvPhkq1Bpc5
                            TR250831H9aCOyJG9G9G40JM9D
                            TR250831P1KDl5paoo6RlDxSby
                            TR250831fPPIzGzT0aLKiHLVTT
                            TR250831x7STj8HCeSm2sdgTez
                            TR2508312YXjyK4okySq8PIIV8
                            TR250831qeIqPuUFU1yFk320Xh
                            TR250831cc866JKDdbgmf8dro7
                            TR250831xVgwH9LhQZy6N0Cqfb
                            31的代付处理一下
                            '
                            
                            那么你提取出来的内容为： TR250831CUzaOLL8N02ePV7ORe
                                                TR250831sxxHjEXCeWlH0QMdA5
                                                TR250831IYnkX3fr1F6YmnaC1E
                                                TR250831D2g97QtwiuVa5bCNrw
                                                TR250831FYKKBd07R4JeTc2Iae
                                                TR250831BF8VfXLZLWXsB5YzQc
                                                TR250831gQW6MdyEky5xjeRExa
                                                TR2508314nKc3tg28rs2Pl6HpS
                                                TR250831oLK3FxDrGEEDXEqnaS
                                                TR250831bRnUop0RDSqZDbYKfX
                                                TR250831XkApJaGy3BNouNLIZb
                                                TR250831JY0r7ZMBypNzYnNIsK
                                                TR250831VOLY7NlbvPhkq1Bpc5
                                                TR250831H9aCOyJG9G9G40JM9D
                                                TR250831P1KDl5paoo6RlDxSby
                                                TR250831fPPIzGzT0aLKiHLVTT
                                                TR250831x7STj8HCeSm2sdgTez
                                                TR2508312YXjyK4okySq8PIIV8
                                                TR250831qeIqPuUFU1yFk320Xh
                                                TR250831cc866JKDdbgmf8dro7
                                                TR250831xVgwH9LhQZy6N0Cqfb
                            
                            返回格式为json格式：
                            
                            {
                                'order_ids':[
                                    'TR250831CUzaOLL8N02ePV7ORe',
                                    'TR250831sxxHjEXCeWlH0QMdA5',
                                    'TR250831IYnkX3fr1F6YmnaC1E',
                                    'TR250831D2g97QtwiuVa5bCNrw',
                                    'TR250831FYKKBd07R4JeTc2Iae',
                                    '',
                                    ......]
                            }
                            
                            严禁输出```json```
                        
                        
                        最后的输出格式为json格式，一定是json，严禁输出其他的内容，
                        
                        禁止返回其他的内容，禁止返回空，
                        
                        严格执行命令。
    
    
                     '''},
                    {"role": "user", "content": prompt},
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            print("LLM Error:", e)
            return "抱歉，AI 处理时出现错误。"
            time.sleep(2)
    raise Exception("多次重试仍然失败")


def ask_llm21(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            # 请求 Chat Completion
            completion = client.chat.completions.create(
                model="deepseek-v3",
                messages=[
                    {"role": "system",
                     "content": '''
    
                        你需要查找user輸入的content，找出这四个字段，以及对应的值，orderInfo字典里面的'amount'和'account'以及对应的值,
                        
                        payoutSourceOrders字典里面中最后一个数组中的的'finish_time'的值,'finish_time'转换为年/月/日格式,时间转换要严谨,转换准确,如果对应的值是空，则为空字符串即可,
                        
                        和payoutSourceOrders字典里面中最后一个数组中'bank_trans_sn'以及对应的值，如果对应的值是空，则为空字符串即可.
                        
                        输出格式为:
                        
                        {
                            'account':'',
                            'amount':'',
                            'finish_time':'',
                            'bank_trans_sn':''
                        }
                        
                        按照上面的格式输出就行，不要输出其他的符号,不要出现''''''。
                        
                        
                        禁止返回其他的内容，严格执行命令。
    
    
                     '''},
                    {"role": "user", "content": prompt},
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            time.sleep(21)
            print("LLM Error:", e)
            # return "抱歉，AI 处理时出现错误。"

    raise Exception("多次重试仍然失败")


def ask_llm22(prompt, save_path):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key="sk-zABGgyHj3rb59p5zzyxkUwLMwUeULUbfTuj7i5Zze8ha5vFS",
                base_url="https://api.moonshot.cn/v1",
            )

            # xlnet.pdf 是一个示例文件, 我们支持 pdf, doc 以及图片等格式, 对于图片和 pdf 文件，提供 ocr 相关能力
            file_object = client.files.create(file=Path(save_path), purpose="file-extract")

            # 获取结果
            # file_content = client.files.retrieve_content(file_id=file_object.id)
            # 注意，之前 retrieve_content api 在最新版本标记了 warning, 可以用下面这行代替
            # 如果是旧版本，可以用 retrieve_content
            file_content = client.files.content(file_id=file_object.id).text

            # 把它放进请求中
            messages = [
                {
                    "role": "system",
                    "content": '''
                    
                    你是我的小助手，你需要根据輸入的pdf,帮我找出账户记为account，
                    时间区间记为time，time转换为年/月/日-年/月/日格式，
                    提取出user的'content'的值,user輸入是一个json，
                    你需要提取出json里面的'bank_trans_sn'对应的值，查找pdf中是否有这个值，如果有，则记为utr,如果没有则为空，
                    如果pdf有对应的utr，则查找utr对应的一行金额记为Credit，金额是正值的，不是负值的金额，找不到金额的则为空，
                        
                        最后输出：
                        {
                            account,
                            time,
                            utr,
                            Credit
                        }
                        
                    
                    禁止输出''''''这些符合,
        
        
                    禁止输出其他的内容。
        
        
                    ''',
                },
                {
                    "role": "system",
                    "content": file_content,
                },
                {"role": "user", "content": prompt},
            ]

            # 然后调用 chat-completion, 获取 Kimi 的回答
            completion = client.chat.completions.create(
                model="kimi-k2-0711-preview",
                messages=messages,
                temperature=0.6,
            )
            return completion.choices[0].message.content
        except Exception as e:
            time.sleep(21)
            print("LLM Error:", e)
            # return "抱歉，AI 处理时出现错误。"

    raise Exception("多次重试仍然失败")


def ask_llm_img(prompt, save_path):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key="sk-zABGgyHj3rb59p5zzyxkUwLMwUeULUbfTuj7i5Zze8ha5vFS",
                base_url="https://api.moonshot.cn/v1",
            )

            # xlnet.pdf 是一个示例文件, 我们支持 pdf, doc 以及图片等格式, 对于图片和 pdf 文件，提供 ocr 相关能力
            file_object = client.files.create(file=Path(save_path), purpose="file-extract")

            # 获取结果
            # file_content = client.files.retrieve_content(file_id=file_object.id)
            # 注意，之前 retrieve_content api 在最新版本标记了 warning, 可以用下面这行代替
            # 如果是旧版本，可以用 retrieve_content
            file_content = client.files.content(file_id=file_object.id).text

            # 把它放进请求中
            messages = [
                {
                    "role": "system",
                    "content": '''

                    首先，你需要知道的是user输入的content是utr账号，不允许你修改这个utr，
                    
                    其次，你需要根据utr账号去system输入的content查找或者匹配一模一样的账号，
                    
                    如果没有匹配到一模一样的账号，返回'让商户提供含有utr的凭证'即可，
                    
                    如果匹配到了一模一样的账号，返回'无'字即可，单纯返回文字，
                    
                    禁止返回其他的符号，禁止返回其他的文字宇内容，

                    禁止输出''''''这些符合,


                    禁止输出其他的内容。


                    ''',
                },
                {
                    "role": "system",
                    "content": file_content,
                },
                {"role": "user", "content": prompt},
            ]

            # 然后调用 chat-completion, 获取 Kimi 的回答
            completion = client.chat.completions.create(
                model="kimi-k2-0711-preview",
                messages=messages,
                temperature=0.6,
            )
            return completion.choices[0].message.content
        except Exception as e:
            time.sleep(21)
            print("LLM Error:", e)
            # return "抱歉，AI 处理时出现错误。"

    raise Exception("多次重试仍然失败")


def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")


def ask_qwen_img_utr(save_path):
    # 将xxxx/eagle.png替换为你本地图像的绝对路径
    base64_image = encode_image(save_path)

    client = OpenAI(
        # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx"
        api_key="sk-fd6c79bf32274aae845c9d3372b6331b",
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    )
    completion = client.chat.completions.create(
        model="qwen-vl-max-latest",
        # 此处以qwen-vl-max-latest为例，可按需更换模型名称。模型列表：https://help.aliyun.com/zh/model-studio/models
        messages=[
            {
                "role": "system",
                "content": [{"type": "text", "text": '''

                        你需要提取图片中的utr账号，有下面几种情况：、
                        1.图片中是utr，2.图片中是UPI transation ID，3.图片中是rrn，4.图片中是ট্রানজেকশন আইডি，你需要根据图片自己判断，是哪一个，然后将对应的内容提取出来，

                        如UPI transation ID，提取出来的值为：559182964263

                        如utr，提取出来的值为：522912483722

                        如UPI Ref NO，提取出来为：523031225323
                        
                        如্রানজেকশন আইডি，提取出来为：74BYPFE1

                        不允许返回空，不允许返回其他的内容，

                        只返回账号信息，其余的不用管，

                        禁止输出其他的内容。


                        ''', }]},
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        # 需要注意，传入Base64，图像格式（即image/{format}）需要与支持的图片列表中的Content Type保持一致。"f"是字符串格式化的方法。
                        # PNG图像：  f"data:image/png;base64,{base64_image}"
                        # JPEG图像： f"data:image/jpeg;base64,{base64_image}"
                        # WEBP图像： f"data:image/webp;base64,{base64_image}"
                        "image_url": {"url": f"data:image/jpg;base64,{base64_image}"},
                    }
                ],
            }
        ],
    )
    return completion.choices[0].message.content

def ask_qwen_video_utr(video_path):
    # 将xxxx/test.mp4替换为你本地视频的绝对路径
    local_path = video_path
    video_path = f"file://{local_path}"
    messages = [{'role': 'system',
                    'content': [{'text': 'You are a helpful assistant.'}]},
                    {'role':'user',
                    # fps参数控制视频抽帧数量，表示每隔1/fps 秒抽取一帧
                    'content': [{'video': video_path,"fps":2},
                                {'text': '''

                        你需要提取视频中的utr账号，有可能是utr，有可能是UPI transation ID，你需要根据图片自己判断，是哪一个，然后将对应的内容提取出来，

                        如UPI transation ID，提取出来的值为：559182964263

                        如utr，提取出来的值为：522912483722

                        如UPI Ref NO，提取出来为：523031225323

                        不允许返回空，不允许返回其他的内容，

                        只返回账号信息，其余的不用管，

                        禁止输出其他的内容。


                        '''}]}]
    response = MultiModalConversation.call(
        # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx"
        api_key="sk-fd6c79bf32274aae845c9d3372b6331b",
        model='qwen-vl-max-latest',
        messages=messages)
    print(response["output"]["choices"][0]["message"].content[0]["text"])
    return response["output"]["choices"][0]["message"].content[0]["text"]


def ask_qwen_video_payout_reversal(video_path,parsed):
    # 将xxxx/test.mp4替换为你本地视频的绝对路径
    local_path = video_path
    video_path = f"file://{local_path}"
    messages = [{'role': 'system',
                 'content': [{'text': '''
                 
                                1.首先你需要根据user传入的content中的text，找到data中的orderInfo中的finish_time的值，然后转换为xxxx/xx/xx，转换到年月日即可，这个时间记作finish_time；然后你再去找到data中的orderInfo中的amount的值，记作amount。
                                
                 
                                2.你需要提取视频中的流水时间和和对应的金额，视频中的金额数值需要准确识别到小数点，不要移动小数点的位置，
                                
                        
                                时间找最大的时间点，判断finish_time是不是在提取的时间前，同一天也不行，只能比视频中的最大时间小，如果是则是y，不是则是n，

                                判断金额amount是不是和视频中的金额相等，要完全相等，小数点后面的也要判断完全相等，不可以有一点偏差，如果相等则是y，不相等则是n，

                                视频中最大的见时间，格式为xxxx/xx/xx，
                                
                                video_amount：这个值填写的过程中，你需要认真的判断，视频中找到金额的和amount相等的值，如果金额数值不相等，则不填写

                                返回的内容：
                                

                                {
                                    'video_max_time':这里填写视频中最大的时间,
                                    'video_order_equal':这里填写视频时间比较的判断结果,
                                    'video_amount':这里填写视频中找到金额的和amount相等的值，如果金额数值不相等，则不填写,
                                    'video_amount_equal':这里填写金额是否相等的判断结果
                                }
                                

                                最后返回的是上面的json格式数据                                

                                不允许返回空，不允许返回其他的内容，

                                禁止输出其他的内容。

                 
                 '''}]},
                {'role': 'user',
                 # fps参数控制视频抽帧数量，表示每隔1/fps 秒抽取一帧
                 'content': [{'video': video_path, "fps": 2},
                             {'text': parsed}]}]
    response = MultiModalConversation.call(
        # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx"
        api_key="sk-fd6c79bf32274aae845c9d3372b6331b",
        model='qwen-vl-max-latest',
        messages=messages)
    # print(response["output"]["choices"][0]["message"].content[0]["text"])
    return response["output"]["choices"][0]["message"].content[0]["text"]



def ask_llm23(prompt):
    for i in range(5):
        try:
            # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
            client = OpenAI(
                api_key=os.getenv("DASHSCOPE_API_KEY"),
                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                # http_client=httpx.Client(transport=transport),
            )

            # 请求 Chat Completion
            completion = client.chat.completions.create(
                model="deepseek-v3",
                messages=[
                    {"role": "system",
                     "content": '''
    
                        你需要查找user輸入的content，輸入的内容为json格式，你需要根据res_pdf里面的值和res_data的值进行对比，
                        
                        首先res_pdf中的'account'对应res_data中的'account'，res_pdf中的'amount'对应res_data中的'Credit'，res_pdf中的'time'对应res_data中的'finish_time'，res_pdf中的'utr'对应res_data中的'bank_trans_sn'。
                        
                        其次，你需要根据上面键比较对应的值，有以下几种情况：
                        
                        第一种：如果res_pdf中的'account'的值和res_data中的'account'的值相等，如果res_pdf中的'amount'的值和res_data中的'Credit'相等，如果res_pdf中的'time'的时间值在res_data中的'finish_time'的时间范围内则表示相等，如果res_pdf中的'utr'的值和res_data中的'bank_trans_sn'的值相等，如果这四个都相等，则返回'已反馈核查，有结果同步您'.
                        
                        第二种：如果res_data中的'finish_time'在res_pdf中的'time'的时间范围内，则返回'流水时间为time，订单信息中订单时间为finish_time，流水与订单时间相符合，已反馈核查，有结果同步您'；如果res_data中的'finish_time'不在res_pdf中的'time'的时间范围内，则返回'流水时间为time，订单信息中订单时间为finish_time，流水与订单时间不相符合，已反馈核查，有结果同步您'.
                        
                        第三种：如果res_pdf中的'account'的值和res_data中的'account'的值不相等，则返回‘流水中银行账户为res_data的account，订单信息中收款账户为res_pdf的account，请联系用户导出对应账户的流水，需要重新提供最新银行流水pdf’。
                        
                        第四种：如果res_pdf中的'amount'的值和res_data中的'Credit'不相等，则返回'稍等我们核实一下'.
                        
                        第五种：如果res_pdf中的'utr'的值和res_data中的'bank_trans_sn'的值不相等，则返回'稍等我们核实一下'.
                        
                        返回答案的过程中，去掉'',纯文字返回，开头需要礼貌用语，按照上面的情况回答。
    
                        禁止返回其他的内容，严格执行命令。
    
    
                     '''},
                    {"role": "user", "content": prompt},
                ]
            )
            return completion.choices[0].message.content
        except Exception as e:
            time.sleep(2)
            print("LLM Error:", e)
            # return "抱歉，AI 处理时出现错误。"
    raise Exception("多次重试仍然失败")


def ask_llm24(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，识别content里面是否有'订单xxx是否提交到我们后台'，或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有，那你就返回’n‘，禁止返回其他的内容，严格执行命令。


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm25(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，提取出订单号即可，返回订单号。
                    
                    如'订单DP250730eqfw8SeqGbdWycgL6a是否提交到我们后台'，提取出来的是'DP250730eqfw8SeqGbdWycgL6a'.返回'DP250730eqfw8SeqGbdWycgL6a'
                    
                    禁止返回其他的内容，严格执行命令


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm26(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，识别content里面是否有'查询余额'，或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有，那你就返回’n‘，禁止返回其他的内容，严格执行命令。


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm27(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，从content中找到'balance'、'freeze_balance'、'unsettled_balance'对应的值，
                    
                    
                    回复格式如下：
                    ‘
                    
                    可用余额：balance
                    冻结余额：freeze_balance
                    ’

                    
                    开头回复需要用礼貌的语气，如‘您好，查询余额为：’，其中'查询'二字不要变动，其他的可以变换不同的语句内容输出，但是意思一样，。
                    
                    禁止返回其他的内容，严格执行命令。
                    
                    

                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm28(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，从content中提取出exchange_rate对应的值，
                    
                    回复格式如下：
                    '
                    
                    下发汇率:exchange_rate
                    '
                    
                    开头回答需要礼貌语气,如：‘您好，您所查询的下发汇率如下：’，可以变换不同的词语，但是最终意思不要变。
                    
                    禁止返回其他的内容，严格执行命令。


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm29(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，识别content里面是否有'查询下发汇率'，或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有，那你就返回’n‘，禁止返回其他的内容，严格执行命令。


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm30():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''
                    
                    
                    你需要从下面的列表中随机挑选一个记为people，然后将people填写到下面的回答中。
                    
                    {
                        '@Levi12318 ',
                        '@carol888 '
                        ‘@samoverhere ’
                    }
                    
                    
                    你需要这样回答：'您好，我目前解答不了您的问题，但是我可以帮您找一位我们的运营人员，这是我们的运营人员people'，你可以对这句话进行语义理解，换成其他的语句输出，但是意思不变，然后返回即可。
                    
                    
                    禁止返回其他的内容，严格执行命令。


                 '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm31(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，识别content里面是否有
                    
                    '代收成功率怎么样'，
                    '通道稳吗？',
                    '代收跑得动吗？',
                    '现在整体成功率多少？',
                    '会员付款失败了，通道正常吗？',
                    '刚才提的几笔都失败了，目前通道正常吗？',
                    ''
                    
                    或者语义相近的意思，同义词，近义词都行，如果有，那你返回’y‘即可，没有，那你就返回’n‘，禁止返回其他的内容，严格执行命令。


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm32(prompt):
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要查找user輸入的content，从content中的值提取出来，作为x，然后将x填写到下面，

                    回复格式如下：
                    '
                    
                    
                    成功率：x
                    ' 
                    
                    
                    输出不需要带''
                    
                    上面填充数据时，只需要将对应的值填充进去即可，不运行自由发挥填充其他的内容。

                    开头回答需要礼貌语气,如：‘您好，您所查询的成功率如下：’，可以变换不同的词语，但是最终意思不要变。

                    禁止返回其他的内容，严格执行命令。


                 '''},
                {"role": "user", "content": prompt},
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"


def ask_llm_identify_time(prompt):
    print("query",prompt)
    try:
        client = OpenAI(
            # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
            # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            # 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
        )

        completion = client.chat.completions.create(
            # 模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
            model="qwen-plus",
            messages=[
                {"role": "system", "content": '''


                            你需要帮我提取时间user中的content中所包含的时间：

                            例子1："1分钟的成功率"，需要提取出来的是1分钟，只需要返回的是1，

                            例子2："1个小时的成功率"，需要提取出来的是1个小时，转换为分钟为60分钟，只需要返回的是60，

                            例子3："1天的成功率"，需要提取出来的是1天，转换为分钟为1440分钟，只需要返回的是1440，

                            ...

                            以此类推，你需要会时间的转换。

                            如果是小时，则转换为分钟，如果是分钟，则还是分钟，

                            最后只需要回复多少分钟即可，即只需要回复数字就行。
                            
                            如果提取不出来时间，则返回无，不需要返回0.


                            禁止回答其余的内容，


                '''},
                {"role": "user", "content": f'''{prompt}'''},
            ],
        )
        print("提取出来的时间为：")
        print(completion.choices[0].message.content)
        return completion.choices[0].message.content
        # 如需查看完整响应，请取消下列注释
        # print(completion.model_dump_json())
    except Exception as e:
        print(f"错误信息：{e}")
        print("请参考文档：https://help.aliyun.com/zh/model-studio/developer-reference/error-code")


def ask_llm_add_rate(prompt):
    print("query", prompt)
    try:
        client = OpenAI(
            # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
            # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            # 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
        )

        completion = client.chat.completions.create(
            # 模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
            model="qwen-plus",
            messages=[
                {"role": "system", "content": '''

                    你需要根据下面的要求完成对user中的content进行改写，记作query，query是个百分数,你需要检查百分数是不是两位小数点，如果是两位小数点，则直接返回，如果不是，则需要转换为两位小数的百分数，然后直接返回，可以参考下面的情况进行判断：
                    
                    1.如果百分数是两位小数点，像"45.34%"，则你直接返回即可，切记不可乱改原来的整数部分，
                    
                    2.如果百分数不是两位小数点，像"31.060000000000002%",你需要转换未"31.06%",转换完成后直接返回，切记不可乱改原来的整数部分，
                    
                    3.如果百分数不是两位小数点，像"31.0%",你需要转换未"31.00%",转换完成后直接返回，切记不可乱改原来的整数部分，
                    
                    返回的是百分数，百分号不要忘记了，
                    
                    禁止返回其他的内容

                '''},
                {"role": "user", "content": f'''{prompt}'''},
            ],
        )
        print("提取出来的时间为：")
        print(completion.choices[0].message.content)
        return completion.choices[0].message.content
        # 如需查看完整响应，请取消下列注释
        # print(completion.model_dump_json())
    except Exception as e:
        print(f"错误信息：{e}")
        print("请参考文档：https://help.aliyun.com/zh/model-studio/developer-reference/error-code")


def ask_llm_native_awakening(prompt):
    print("query", prompt)
    try:
        client = OpenAI(
            # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
            # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            # 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
        )

        completion = client.chat.completions.create(
            # 模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
            model="qwen-plus",
            messages=[
                {"role": "system", "content": '''

                    首先这里是一个user的content的title，你需要帮我从title中提取出小数我下面给你几个列子：
                    
                    例子1："12322-Deepay&yesspinHX5.4+3+6",提取出来的为"5.4",则直接返回5.4即可，其余的内容不用返回，
                    
                    例子2："12163-DD1 & DeePay原生9.5+3+6"，提取出来的为"9.5",则直接返回9.5即可，其余的内容不用返回，
                    
                    例子3："12262-Bigowin &Deepay🇮🇳原生9.6+3+6",提取出来的为"9.6",则直接返回9.6即可，其余的内容不用返回，
                    
                    只需要提取出title中的小数即可，然后返回，其余的内容不用返回。
                    
                    切记回复的是title中的小数，不要乱回答
                    
                    禁止回答其余的内容

                '''},
                {"role": "user", "content": f'''{prompt}'''},
            ],
        )
        print("提取出来的时间为：")
        print(completion.choices[0].message.content)
        return completion.choices[0].message.content
        # 如需查看完整响应，请取消下列注释
        # print(completion.model_dump_json())
    except Exception as e:
        print(f"错误信息：{e}")
        print("请参考文档：https://help.aliyun.com/zh/model-studio/developer-reference/error-code")


def ask_llm4_0():
    try:
        # 初始化 OpenAI 兼容客户端（用于阿里云百炼 DashScope）
        client = OpenAI(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            # http_client=httpx.Client(transport=transport),
        )

        # 请求 Chat Completion
        completion = client.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system",
                 "content": '''

                    你需要从下面的字典中，任意挑选一个或者两个返回给我，
                    
                    {
                        '@ganfin ',
                        '@DP_clala ',
                        '@DP_Creese ',
                        '@Lornaiiiiiiii ',
                        '@DP_lad ',
                        '@DP_Teeee ',
                        '@DP_Tddddd ',
                        '@DP_Gkoo ',
                        '@DP_Cecil ',
                        '@DP_baobao ',
                        '@Christinnaa1819 ',
                        '@Talise01 ',
                        '@carol888 ',
                        '@samoverhere '
                        '@Levi12318 ',
                        
                    }
                    
                    仅需要返回字典中的内容，其余的不要返回，
                    
                    禁止返回其他的没有用的内容

                 '''}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        print("LLM Error:", e)
        return "抱歉，AI 处理时出现错误。"